package com.shitou.springai1.admin.service.impl;


import com.baomidou.mybatisplus.core.conditions.query.QueryWrapper;
import com.baomidou.mybatisplus.core.metadata.IPage;
import com.baomidou.mybatisplus.extension.plugins.pagination.Page;
import com.baomidou.mybatisplus.extension.service.impl.ServiceImpl;
import com.shitou.springai1.admin.entity.dto.ImageDto;
import com.shitou.springai1.admin.entity.dto.KeywordsDto;
import com.shitou.springai1.admin.entity.vo.ImagesVo;
import com.shitou.springai1.admin.mapper.ImageKeywordsMapper;
import com.shitou.springai1.admin.mapper.ImagesMapper;
import com.shitou.springai1.admin.service.ImagesService;
import lombok.RequiredArgsConstructor;
import org.springframework.stereotype.Service;
import org.springframework.transaction.annotation.Transactional;

import java.util.*;
import java.util.stream.Collectors;

@Service
@RequiredArgsConstructor
public class ImagesServiceImpl extends ServiceImpl<ImagesMapper, ImageDto> implements ImagesService {

    //注入关键字子表
    private final ImageKeywordsMapper imageKeywordsMapper;


    /*
    * 保存图片
    * @param imageDto
    * @return
    * */
    @Override
    @Transactional(rollbackFor = Exception.class)
    public boolean saveImage(ImageDto imageDto) {
        //为图片生成一个唯一的id
        String images_id = UUID.randomUUID().toString();
        imageDto.setImagesId(images_id);
        //保存图片
        boolean save = this.save(imageDto);
        if (!save){
            return false;
        }
        //保存图片的关键词
        List<String> keywords = imageDto.getKeywords();
        if (keywords != null && keywords.size() > 0){
            keywords.forEach(keyword -> {
                KeywordsDto keywordsDto = KeywordsDto.builder()
                        .imagesId(images_id)
                        .keyword(keyword)
                        .build();
                imageKeywordsMapper.insert(keywordsDto);
            });
        }
        return true;
    }



    /*
    * 获取图片列表
    * @param pageNum
    * @param pageSize
    * @param keyword
    * @return
    * */
    @Override
    public List<Map<String, Object>> getImages(int pageNum, int pageSize, String keyword) {
        // 1. 分页查询图片（增加空值防护，避免pageNum/pageSize非法）
        if (pageNum < 1) pageNum = 1;
        if (pageSize < 1 || pageSize > 100) pageSize = 6; // 限制最大页大小，避免性能问题
        Page<ImageDto> page = new Page<>(pageNum, pageSize);

        // 2. 构建查询条件（优化关键词模糊查询，避免null导致的条件失效）
        QueryWrapper<ImageDto> queryWrapper = null;
        if (keyword != null && !keyword.trim().isEmpty()) {
            queryWrapper = new QueryWrapper<ImageDto>()
                    .like("images_name", keyword.trim()) // 去除关键词空格，避免无效查询
                    .or()
                    .like("description", keyword.trim());
        }

        // 3. 执行分页查询
        IPage<ImageDto> imageDtoIPage = this.page(page, queryWrapper);
        List<ImageDto> imageDtos = imageDtoIPage.getRecords();

        // 4. 转换为Map列表（核心修复：关键词Stream收集为List）
        return imageDtos.stream().map(imageDto -> {
            Map<String, Object> map = new HashMap<>();
            // 基础字段（增加空值默认值，避免JSON序列化时出现null字段）
            map.put("id", imageDto.getId());
            map.put("imagesId", imageDto.getImagesId() == null ? "" : imageDto.getImagesId()); // 关键：避免imagesId为null
            map.put("imagesName", imageDto.getImagesName() == null ? "" : imageDto.getImagesName());
            map.put("imagesUrl", imageDto.getImagesUrl() == null ? "" : imageDto.getImagesUrl());
            map.put("description", imageDto.getDescription() == null ? "" : imageDto.getDescription());
            map.put("startTime", imageDto.getStartTime());
            map.put("updateTime", imageDto.getUpdateTime());

            // 5. 查询关键词（增加imagesId空值防护，避免无效查询）
            List<KeywordsDto> keywordsDtos = new ArrayList<>();
            String imagesId = imageDto.getImagesId();
            if (imagesId != null && !imagesId.trim().isEmpty()) {
                keywordsDtos = imageKeywordsMapper.selectList(
                        new QueryWrapper<KeywordsDto>()
                                .eq("images_id", imagesId.trim())// 去除空格，避免匹配失败
                );
            }
            // 核心修复：将Stream收集为List<String>，确保Jackson可序列化
            List<String> keywords = keywordsDtos.stream()
                    .map(KeywordsDto::getKeyword)
                    .filter(kw -> kw != null && !kw.trim().isEmpty()) // 过滤空关键词
                    .collect(Collectors.toList());
            map.put("keywords", keywords);
            return map;
        }).collect(Collectors.toList());
    }


    /*
    * 根据id查询图片及其关键词
    * @param id
    * @return
    * */
    @Override
    public ImageDto getByIdWithKeywords(int id) {
        // 1. 查询图片基本信息
        ImageDto imageDto = this.getById(id);
        if (imageDto == null) {
            return null; // 图片不存在
        }

        // 2. 查询关联的关键词（增加imagesId空值防护）
        List<KeywordsDto> keywordsDtos = new ArrayList<>();
        String imagesId = imageDto.getImagesId();
        if (imagesId != null && !imagesId.trim().isEmpty()) {
            keywordsDtos = imageKeywordsMapper.selectList(
                    new QueryWrapper<KeywordsDto>()
                            .eq("images_id", imagesId.trim()) // 去除空格，避免匹配失败
            );
        }

        // 3. 转换关键词为List<String>
        List<String> keywords = keywordsDtos.stream()
                .map(KeywordsDto::getKeyword)
                .filter(kw -> kw != null && !kw.trim().isEmpty()) // 过滤空关键词
                .collect(Collectors.toList());
        imageDto.setKeywords(keywords); // 设置到ImageDto中

        return imageDto;
    }


        /*
        * 更新图片
        * @param id
        * @param imagesVo
        * @return
        * */
    @Override
    public boolean updateImage(int id, ImagesVo imagesVo) {
        ImageDto imageDto = this.getById(id);
        if (imageDto == null) {
            return false; // 图片不存在
        }
        imageDto.setImagesName(imagesVo.getImagesName());
        imageDto.setImagesUrl(imagesVo.getImagesUrl());
        imageDto.setDescription(imagesVo.getDescription());
        imageDto.setKeywords(imagesVo.getKeywords());
        // 3. 更新图片关键词
        // 先删除旧关键词
        imageKeywordsMapper.delete(
                new QueryWrapper<KeywordsDto>()
                        .eq("images_id", imageDto.getImagesId())
        );
        // 保存新关键词
        if (imagesVo.getKeywords() != null && imagesVo.getKeywords().size() > 0) {
            imagesVo.getKeywords().forEach(keyword -> {
                KeywordsDto keywordsDto = KeywordsDto.builder()
                        .imagesId(imageDto.getImagesId())
                        .keyword(keyword)
                        .build();
                imageKeywordsMapper.insert(keywordsDto);
            });
        }
        return this.updateById(imageDto);

    }

    @Override
    public List<ImageDto> getALLImages() {
        return List.of();
    }
}

